Slip 16

Q.1. Create a two layered neural network with relu and sigmoid activation function.

import numpy as np

# Activation functions
def relu(x):
    return np.maximum(0, x)

def relu_derivative(x):
    return np.where(x > 0, 1, 0)

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    s = sigmoid(x)
    return s * (1 - s)

# Two-layer neural network
class TwoLayerNN:
    def __init__(self, input_size, hidden_size, output_size, learning_rate=0.01):
        # Initialize weights
        self.W1 = np.random.randn(input_size, hidden_size) * 0.01
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) * 0.01
        self.b2 = np.zeros((1, output_size))
        self.lr = learning_rate

    def forward(self, X):
        # Hidden layer
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = relu(self.z1)

        # Output layer
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = sigmoid(self.z2)
        return self.a2

    def backward(self, X, y):
        m = X.shape[0]

        # Output layer error
        dz2 = self.a2 - y
        dW2 = (1/m) * np.dot(self.a1.T, dz2)
        db2 = (1/m) * np.sum(dz2, axis=0, keepdims=True)

        # Hidden layer error
        dz1 = np.dot(dz2, self.W2.T) * relu_derivative(self.z1)
        dW1 = (1/m) * np.dot(X.T, dz1)
        db1 = (1/m) * np.sum(dz1, axis=0, keepdims=True)

        # Update weights
        self.W1 -= self.lr * dW1
        self.b1 -= self.lr * db1
        self.W2 -= self.lr * dW2
        self.b2 -= self.lr * db2

    def train(self, X, y, epochs=1000):
        for i in range(epochs):
            self.forward(X)
            self.backward(X, y)
            if i % 100 == 0:
                loss = -np.mean(y*np.log(self.a2+1e-8) + (1-y)*np.log(1-self.a2+1e-8))
                print(f"Epoch {i}, Loss: {loss:.4f}")


# Example usage
if __name__ == "__main__":
    # XOR dataset
    X = np.array([[0,0],[0,1],[1,0],[1,1]])
    y = np.array([[0],[1],[1],[0]])

    nn = TwoLayerNN(input_size=2, hidden_size=4, output_size=1, learning_rate=0.1)
    nn.train(X, y, epochs=1000)

    # Predictions
    print("Predictions:")
    print(nn.forward(X))

Q.2. Write a python program to implement Simple Linear Regression for Boston housing 
dataset. 

# simple_linear_regression_boston.py

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_openml
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# ------------------------------
# Step 1: Load the Boston Housing Dataset
# ------------------------------
boston = fetch_openml(name='boston', version=1, as_frame=True)
data = boston.frame

# Display the first few rows
print("Boston Housing Dataset Sample:")
print(data.head(), "\n")

# ------------------------------
# Step 2: Select One Feature for Simple Linear Regression
# ------------------------------
# We'll use 'RM' (average number of rooms per dwelling) as the predictor
X = data[['RM']]   # Independent variable
y = data['MEDV']   # Dependent variable (Median value of owner-occupied homes)

# ------------------------------
# Step 3: Split Dataset into Training and Testing Sets
# ------------------------------
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# ------------------------------
# Step 4: Train the Simple Linear Regression Model
# ------------------------------
model = LinearRegression()
model.fit(X_train, y_train)

# ------------------------------
# Step 5: Make Predictions
# ------------------------------
y_pred = model.predict(X_test)

# ------------------------------
# Step 6: Evaluate the Model
# ------------------------------
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print("Simple Linear Regression (Feature: RM)")
print(f"Intercept: {model.intercept_:.2f}")
print(f"Coefficient: {model.coef_[0]:.2f}")
print(f"Mean Squared Error: {mse:.2f}")
print(f"R² Score: {r2:.4f}")

# ------------------------------
# Step 7: Visualize the Results
# ------------------------------
plt.scatter(X_test, y_test, color='blue', label='Actual Prices')
plt.plot(X_test, y_pred, color='red', linewidth=2, label='Regression Line')
plt.xlabel('Average Number of Rooms per Dwelling (RM)')
plt.ylabel('Median Home Value (MEDV)')
plt.title('Simple Linear Regression - Boston Housing Dataset')
plt.legend()
plt.show()